
    var 换号次数 = 0
    var 没有加载脚本 = 0
    var 现在条数 = null;
    var 今日条数 = null;
    var 最后有效今日条数 = null;
    var version = "1.0.001"; //当前版本号
    toast("当前版本 -> " + version);
    device.keepScreenOn();//保持屏幕唤醒
    ui.showLogWindow();//显示日志
    const x = device.getScreenWidth();
    y = device.getScreenHeight(); //屏幕的横坐标 x //屏幕的纵坐标 y
    var m = {
        "x": x / 1.1, "y": y / 1.7,
    }
    setCtrlViewSizeEx(m);//设置启停位置
    showCtrlWindow();//显示启停
    setTimeout(function () {
        ui.closeLogWindow();
    }, 5000); //5秒后关闭日志
    var toastExtra = {
        "x": x / 1,
        "y": y / 1.35,
        "width": x / 7,
        "height": y / 7,
        "duration": 120000,
        "textColor": "#1dfc04",
        "draggable": false
    }//toast窗口位置
    var 编号 = readConfigString("编号");//读取字符串数据//readConfigLong readConfigLong是读取数字?
    var 账号 = readConfigString("账号");//读取字符串数据
    var 密码 = readConfigString("密码");//读取字符串数据
    var 账号2 = readConfigString("账号2");//读取字符串数据
    var 密码2 = readConfigString("密码2");//读取字符串数据
    var 账号3 = readConfigString("账号3");//读取字符串数据
    var 密码3 = readConfigString("密码3");//读取字符串数据
    var 账号4 = readConfigString("账号4");//读取字符串数据
    var 密码4 = readConfigString("密码4");//读取字符串数据
    var 账号5 = readConfigString("账号5");//读取字符串数据
    var 密码5 = readConfigString("密码5");//读取字符串数据
    var 账号6 = readConfigString("账号6");//读取字符串数据
    var 密码6 = readConfigString("密码6");//读取字符串数据
    var 账号7 = readConfigString("账号7");//读取字符串数据
    var 密码7 = readConfigString("密码7");//读取字符串数据
    var 账号8 = readConfigString("账号8");//读取字符串数据
    var 密码8 = readConfigString("密码8");//读取字符串数据
    var 账号9 = readConfigString("账号9");//读取字符串数据
    var 密码9 = readConfigString("密码9");//读取字符串数据
    var 单选一 = readConfigString("one");
    var 单选二 = readConfigString("two");
    var 单选三 = readConfigString("three");
    var 单选四 = readConfigString("four");
    var 服务器账号状态链接 = 'http://8.140.243.126:8088/xystatus'

    /*    var 账号正常 = JSON.stringify({"num": 本机编号, "xystatus": "在线",})
        thread.execAsync(function () {
            try {
                while (true) {
                    logd("检测")
                    sleep(1000)
                    let 正常状态 = http.postJSON(服务器账号状态链接, 账号正常, 10 * 1000, {"User-Agent": "test"});
                    logd(账号正常 + "登录")
                    if (正常状态 === "OK") {
                        logd("成功")
                        sleep(1000)
                    } else {
                        logd("失败")
                        sleep(10000)
                        let 正常状态 = http.postJSON(服务器账号状态链接, 账号正常, 10 * 1000, {"User-Agent": "test"});
                        logd(账号正常 + "登录")
                        if (正常状态 === "OK") {
                            logd("成功")
                            sleep(1000)
                        } else {
                            logd("失败")
                            sleep(1000)
                        }
                    }
                    sleep(1140 * 1000)
                }
            } catch (e) {
                logw("出错")
                sleep(1000)
            }
        });//上传服务器编号*/
    thread.execAsync(function () {


        for (; ;) {
            let cm = context.getSystemService(context.CONNECTIVITY_SERVICE);
            let net = cm.getActiveNetworkInfo();
            if (net == null || !net.isAvailable()) {
                toast("网络未连接");
                sleep(1000)
                toast("网络未连接");
                sleep(1000)
                shell.execCommand("input keyevent 26");
                toast("电源键")
                sleep(10000)
                shell.execCommand("input keyevent 26");
                toast("电源键")
                sleep(5000)
            }
            if (查找节点点击("关闭应用", text("关闭应用"), 1, 100)) {
                logd("关闭应用");
                sleep(3000);
            }
            if (查找节点点击("忘记密码", text("忘记密码").index(1).depth(9), 1000, 100)) {
                logd("忘记密码")
                back()
                sleep(1100)
            }
            if (查找节点点击("X浏览器更新", id("com.mmbox.xbrowser:id/btn_close"), 1, 100)) {
                logd("X浏览器更新")
                sleep(100)
            }
            if (查找节点点击("继续", text("继 续"), 1, 100)) {
                logd("继续");
                sleep(2000);
            }

            if (查找节点点击("允许", text("允许"), 1, 100)) {
                logd("允许");
                sleep(2000);
            }
            let TB滑块 = getOneNodeInfo(text("验证码拦截"), 500)
            if (TB滑块) {
                let 带盾的滑块 = getOneNodeInfo(text("为了您的账号安全，需要进行安全校验"), 500)
                if (带盾的滑块) {
                    moveFun(x * 0.138, y * 0.714, x * 0.958, y * 0.711, 61, 101)
                    sleep(5500);
                    let 没有划过滑块 = getOneNodeInfo(text("验证码拦截"), 1000)
                    if (没有划过滑块) {
                        clickPoint(x * 0.501, y * 0.71);
                        sleep(1000);
                        moveFun(x * 0.138, y * 0.714, x * 0.958, y * 0.711, 41, 101)
                        sleep(5500);
                        let 没有划过滑块2 = getOneNodeInfo(text("验证码拦截"), 1000)
                        if (没有划过滑块2) {
                            clickPoint(x * 0.501, y * 0.71);
                            sleep(1000);
                            moveFun(x * 0.138, y * 0.714, x * 0.958, y * 0.711, 21, 101)
                            sleep(5500);
                            let 没有划过滑块3 = getOneNodeInfo(text("验证码拦截"), 1000)
                            if (没有划过滑块3) {
                                sleep(20000)
                                back()
                                sleep(1000);
                            }
                        }

                    }
                } else {
                    let 电视的滑块 = getOneNodeInfo(text("亲，请拖动下方滑块完成验证"), 500)
                    if (电视的滑块) {
                        moveFun(x * 0.143, y * 0.667, x * 0.958, y * 0.666, 61, 101)
                        sleep(5500);
                        let 没有划过滑块 = getOneNodeInfo(text("验证码拦截"), 1000)
                        if (没有划过滑块) {
                            clickPoint(x * 0.480, y * 0.651);
                            sleep(1000);
                            moveFun(x * 0.143, y * 0.667, x * 0.958, y * 0.666, 41, 101)
                            sleep(5500);
                            let 没有划过滑块2 = getOneNodeInfo(text("验证码拦截"), 1000)
                            if (没有划过滑块2) {
                                clickPoint(x * 0.480, y * 0.651);
                                sleep(1000);
                                moveFun(x * 0.143, y * 0.667, x * 0.958, y * 0.666, 21, 101)
                                sleep(5500);
                                let 没有划过滑块3 = getOneNodeInfo(text("验证码拦截"), 1000)
                                if (没有划过滑块3) {
                                    sleep(2000)
                                    back()
                                    sleep(1000);
                                }
                            }

                        }
                    } else {
                        let TB滑块 = getOneNodeInfo(text("验证码拦截"), 500)
                        if (TB滑块) {
                            back()
                            sleep(1500)
                        }

                    }
                }
            }

            // if (查找节点点击("验证码拦截", text("验证码拦截"), 11, 11)) {
            //     if (查找节点点击("验证码拦截", text("为了您的账号安全，需要进行安全校验"),)) {
            //         logd("带盾的滑块")
            //         sleep(1000)
            //         moveFun(150, 1416, 1013, 1411, 2240, 4500, 800)
            //         sleep(5500);
            //         if (查找节点点击("验证码拦截", text("为了您的账号安全，需要进行安全校验"), 11, 11)) {
            //             clickPoint(534, 1411);
            //             sleep(1000);
            //             logd("带盾的滑块")
            //             sleep(1000)
            //             moveFun(150, 1416, 1013, 1411, 2240, 4500, 800)
            //             sleep(5500);
            //             if (查找节点点击("验证码拦截", text("为了您的账号安全，需要进行安全校验"), 11, 11)) {
            //                 clickPoint(534, 1411);
            //                 sleep(1000);
            //                 logd("带盾的滑块")
            //                 sleep(1000)
            //                 moveFun(150, 1416, 1013, 1411, 2240, 4500, 800)
            //                 sleep(5500);
            //                 if (查找节点点击("验证码拦截", text("为了您的账号安全，需要进行安全校验"), 11, 11)) {
            //                     logd("没划过去")
            //                     sleep(20000)
            //                     back()
            //                     sleep(1000);
            //
            //                 }
            //             }
            //         }
            //     } else {
            //         logd("电视的滑块")
            //         sleep(1000)
            //         moveFun(142, 1272, 1033, 1273, 2240, 4500, 800)
            //         sleep(5500);
            //         if (查找节点点击("验证码拦截", text("验证码拦截"), 11, 11)) {
            //             clickPoint(508, 1257);
            //             sleep(1000);
            //             moveFun(142, 1272, 1033, 1273, 2240, 4500, 800)
            //             sleep(5500);
            //             if (查找节点点击("验证码拦截", text("验证码拦截"), 11, 11)) {
            //                 clickPoint(508, 1257);
            //                 sleep(1000);
            //                 moveFun(142, 1272, 1033, 1273, 2240, 4500, 800)
            //                 sleep(5500);
            //                 if (查找节点点击("没划过去", text("验证码拦截"), 11, 11)) {
            //                     logd("没划过去")
            //                     sleep(20000)
            //                     back()
            //                     sleep(1000);
            //
            //                 }
            //             }
            //         }
            //     }
            // }

            if (查找节点点击("崩溃退出", text("复制崩溃信息"), 11, 11)) {
                if (查找节点点击("崩溃退出", text("退出"), 1, 11)) {
                    logd("崩溃退出")
                    sleep(1000)
                }
            }
            if (查找节点点击("允许", text("允许"), 1, 11)) {
                logd("允许")
                sleep(1000)
            }
            if (查找节点点击("重新打开应用", text("重新打开应用").id("android:id/aerr_restart"), 1, 11)) {
                logd("重新打开应用")
                sleep(1000)
            }

        }

    });//弹窗线程
    /*thread.execAsync(function () {
        logw("更新线程");
        sleep(100);
        while (true) {
            sleep(10010);
            let 定时1 = "9:55", 定时2 = "15:33", 定时3 = "18:06", 定时4 = "星期2的3:19", 定时5 = "星期4的3:19", 定时6 = "星期6的3:19";
            let 时 = new Date().getHours(), 分 = new Date().getMinutes(), 星期 = new Date().getDay();
            let 时间 = (时) + ":" + (分);
            let 关机时间 = "星期" + (星期) + "的" + (时) + ":" + (分);
            if (时间 == 定时1) {
                sleep(60000);
                更新();
            }
            // if (时间 == 定时2) {
            //     sleep(60000);
            //     更新();
            // }
            // if (时间 == 定时3) {
            //     sleep(60000);
            //     更新();
            // }
        }
    });//更新线程*/

    /*  let 屏幕亮度 = device.getBrightness()
      if (屏幕亮度 == 0) {
          logd("亮度0")
          sleep(100)
      } else {
          try {
              device.setBrightness(0)//设置亮度0
              sleep(1000)
          } catch (e) {
              logw("出错")
              sleep(1000)
              let 允许修改系统设置 = getOneNodeInfo(text("允许修改系统设置"), 3000)
              if (允许修改系统设置) {
                  允许修改系统设置.click()
                  sleep(2000)
                  back()
                  sleep(1000)
                  back()
                  sleep(1000)
                  back()
                  sleep(1000)
                  try {
                      device.setBrightness(0)//设置亮度0
                      sleep(1000)
                  } catch (e) {
                      logw("出错")
                      sleep(1000)
                  }
              }
          }
      } //设置亮度0*/
    for (let i = 0; i < 60; i++) {
        let 本机当前时间年 = timeFormat("yyyy");
        logd(本机当前时间年)
        if (本机当前时间年 < 2024) {
            logd("时间小于2024年")
            sleep(1000)
            utils.openIntentAction("android.settings.DATE_SETTINGS")
            toast("进入时间")
            sleep(2000)
            let 自动日期开关 = getOneNodeInfo(text("自动确定日期和时间"), 3000)
            if (自动日期开关) {
                (自动日期开关).click()
                sleep(8000)
                if (自动日期开关) {
                    (自动日期开关).click()
                    sleep(3000)
                }
            }
        } else {
            break
        }
    }//检测时间对错
    sleep(1000)
    let 本机当前时间年 = timeFormat("yyyy");
    if (本机当前时间年 < 2024) {
        logd("时间小于2024年")
        sleep(1000)
        shell.execCommand("reboot");
    }
    var IP网址 = "http://checkip.amazonaws.com/";
    var pa = {"b": "22"};
    var 现在的IP = http.httpGet(IP网址, pa, 3000, {"User-Agent": "test"});
    logd(现在的IP)
    sleep(1000)
    var IP文件1 = file.exists("/sdcard/IP.txt/");
    sleep(1010)
    if (IP文件1 == false) {
        sleep(100)
        file.appendLine(现在的IP, "/sdcard/IP.txt");
        sleep(1000)
    } else {
        file.writeFile(现在的IP, "/sdcard/IP.txt");
        sleep(1000)
    }

    sleep(100)
    if (单选一 == "true") {
        logd("选择的是111")
        sleep(1000)
        thread.execAsync(function () {
            logw("检测条数线程");
            sleep(100);
            for (; ;) {
                for (let i = 0; i < 60; i++) {
                    今日条数 = getOneNodeInfo(id("today_num"), 1000);
                    if (今日条数) {
                        toast(i + "--→" + 今日条数.text, toastExtra);
                        sleep(1000);
                        let 开始任务状态 = getOneNodeInfo(id("gdp-start-task"), 500);
                        if (开始任务状态) {
                            i = 0;
                        }
                        最后有效今日条数 = 今日条数; // 更新最后有效今日条数
                    } else {
                        sleep(1000);
                        i = 0;
                    }
                }

                现在条数 = getOneNodeInfo(id("today_num"), 1000);
                if (现在条数) {
                    sleep(100);
                    if (现在条数.text == 今日条数.text) {
                        logd("卡住了");
                        sleep(1000);
                        home();
                        sleep(1000);
                    }
                }
            }
        });//条数线程
        X浏览器()
    } else {
        if (单选二 == "true") {
            logd("选择的是222")
            sleep(1000)
            thread.execAsync(function () {
                logw("检测条数线程");
                sleep(100);
                for (; ;) {
                    for (let i = 0; i < 60; i++) {
                        var 记下领取数量 = getOneNodeInfo(id("task-total"), 500);
                        if (记下领取数量 && 记下领取数量 !== null) {
                            var 插件日志 = getOneNodeInfo(id("best_new_log"), 500);
                            if (插件日志) {
                                var 插件日志的子节点 = 插件日志.child(0)
                                if (插件日志的子节点) {
                                    var 插件日志的文本 = 插件日志的子节点.text;
                                    sleep(100)
                                }
                                if (插件日志的文本 && 插件日志的文本 !== undefined && 插件日志的文本 !== null) {
                                    var 任务队列为空 = "任务队列为空";
                                    if (插件日志的文本.includes(任务队列为空)) {
                                        sleep(1000);
                                        i = 0;
                                    }
                                }
                            }
                            toast(i + "--→" + 记下领取数量.text);
                            sleep(1000);
                        } else {
                            sleep(1000);
                            i = 0;
                        }
                    }

                    let 现在的条数 = getOneNodeInfo(id("task-total"), 500);
                    if (现在的条数 && 现在的条数 !== null) {
                        sleep(100);
                        if (现在的条数.text == 记下领取数量.text) {
                            logd("卡住了");
                            sleep(1000);
                            if (查找节点点击("点主页", id("com.lemurbrowser.exts:id/home_button"), 1, 1500)) {
                                logd("点主页")
                                sleep(1100)
                            }
                        }
                    }
                }
            });//狐猴条数线程
            狐猴()
        } else {
            if (单选三 == "true") {
                logd("选择的是333")
                sleep(1000)
                任务3()
            } else {
                if (单选四 == "true") {
                    logd("选择的是444")
                    sleep(1000)
                    任务4()
                } else {
                    logd("没有选择")
                    sleep(100);
                    ui.saveConfig("one", true);
                    sleep(100)
                    ui.saveConfig("two", false);
                    sleep(100)
                    ui.saveConfig("three", false);
                    sleep(100)
                    ui.saveConfig("four", false);
                    sleep(100)
                    ui.openECSystemSetting();
                    sleep(500)
                    let 脚本系统设置界面 = getOneNodeInfo(text("系统设置").id("com.gibb.easyclick:id/tv_title"), 15000)
                    if (脚本系统设置界面) {
                        back()
                        sleep(500)
                        back()
                        sleep(500)
                        back()
                        sleep(500)
                    }
                    let id2 = startJob("task2", "4", true);
                    toast("job id " + id2);
                    sleep(1000)
                    exit()
                }
            }
        }
    }

    function 任务1() {
        logd("执行任务一")
        sleep(100);

    }

    function 任务2() {
        logd("执行任务二")
        sleep(100)
        for (; ;) {
            try {

            } catch (e) {
                logw("出错")
                sleep(1000)
            }
        }
    }

    function 任务3() {
        logd("执行任务三")
        sleep(100)
        for (; ;) {
            try {

            } catch (e) {
                logw("出错")
                sleep(1000)
            }
        }
    }

    function 任务4() {
        logd("执行任务四")
        sleep(100)
        for (; ;) {
            try {

            } catch (e) {
                logw("出错")
                sleep(1000)
            }
        }
    } //选择任务类型

    function 狐猴() {
        home()
        sleep(1000)
        home()
        sleep(1000)

        for (; ;) {
            let 狐猴界面 = getOneNodeInfo(pkg("com.lemurbrowser.exts"), 500);
            if (狐猴界面) {
                sleep(100);
                if (查找节点点击("插件存在", id("task-platform"), 1000, 500)) {
                    sleep(100)
                } else if (查找节点点击("插件存在", id("task-platform"), 1000, 10500)) {
                    sleep(100)
                } else {
                    logd("插件不存在")
                    sleep(100)
                    if (查找节点点击("更多选项", id("com.lemurbrowser.exts:id/menu_button_lemur").desc("更多选项"), 1, 3500)) {
                        logd("更多选项")
                        sleep(1100)
                        if (查找节点点击("刷新", id("com.lemurbrowser.exts:id/tv").text("刷新"), 1, 3500)) {
                            logd("刷新")
                            sleep(4100)
                        }
                    }
                }
            } else {
                utils.openAppByName("狐猴浏览器");
                logd("启动狐猴浏览器");
                sleep(5000);
                if (查找节点点击("插件界面", id("task-platform"), 1000, 30000)) {
                    logd("插件界面")
                    sleep(3100)
                    let 手机号为空 = getOneNodeInfo(id("task-userId"), 1500)
                    if (手机号为空) {
                        if (手机号为空.text == undefined) {
                            手机号为空.click()
                            sleep(1000)
                            手机号为空.inputText("15345497775");
                            sleep(1000);
                        }
                    }
                    if (查找节点点击("清空", id("task-clear"), 1, 1500)) {
                        logd("清空")
                        sleep(1100)
                        if (查找节点点击("停止任务", id("task-start").text("停止任务"), 1, 1500)) {
                            logd("停止任务")
                            sleep(1010)
                        } else {
                            if (查找节点点击("开始任务", id("task-start").text("开始任务"), 1, 1500)) {
                                logd("开始任务")
                                sleep(1100)
                            }
                        }
                    }
                } else {
                    logd("没有插件")
                    sleep(1100)
                    停止应用("com.lemurbrowser.exts")
                    sleep(1100)
                }

            }
            let 插件版本 = getOneNodeInfo(id("task-platform"), 500)
            if (插件版本) {
                let 插件版本文本 = 插件版本.text;
                sleep(100)
                if (插件版本文本 && 插件版本文本 !== "JD插件5.6") {
                    logd("需要更新")
                    if (查找节点点击("更多选项", id("com.lemurbrowser.exts:id/menu_tools").desc("更多选项"), 1, 11500)) {
                        logd("更多选项")
                        sleep(100)
                        if (查找节点点击("扩展管理", text("扩展管理").id("com.lemurbrowser.exts:id/tv"), 1, 11500)) {
                            logd("扩展管理")
                            sleep(100)
                            if (查找节点点击("移除", text("移除").id("removeButton"), 1, 11500)) {
                                logd("移除")
                                sleep(100)
                                if (查找节点点击("确定", text("确定").id("com.lemurbrowser.exts:id/positive_button"), 1, 11500)) {
                                    logd("确定")
                                    sleep(100)
                                    if (查找节点点击("退出", text("退出").id("com.lemurbrowser.exts:id/left_button"), 1, 11500)) {
                                        logd("退出")
                                        sleep(100)
                                    }
                                    let 加载 = getOneNodeInfo(text("加载 CRX/ZIP").id("loadUnpacked"), 11000)
                                    if (加载) {
                                        加载.click()
                                        sleep(1000)
                                        let 插件 = getOneNodeInfo(text("jd5.6.zip"), 11000)
                                        if (插件) {
                                            插件.click()
                                            sleep(5000)

                                            let 首页 = getOneNodeInfo(desc("首页").id("com.lemurbrowser.exts:id/home_button"), 10000)
                                            if (首页) {
                                                首页.click()
                                                sleep(5000)
                                            }

                                        }

                                    }
                                }
                            }
                        }
                    }
                }
            }

            var 插件日志 = getOneNodeInfo(id("best_new_log"), 500);
            if (插件日志) {
                var 插件日志的子节点 = 插件日志.child(0)
                if (插件日志的子节点) {
                    var 插件日志的文本 = 插件日志的子节点.text;
                    sleep(100)
                }
                if (插件日志的文本 && 插件日志的文本 !== undefined && 插件日志的文本 !== null) {
                    var 验证页面 = "验证页面";
                    if (插件日志的文本.includes(验证页面)) {
                        logd("日志包含验证页面");
                        sleep(1000);
                        换号();
                    }
                    var 此账号暂时风控 = "此账号暂时风控";
                    if (插件日志的文本.includes(此账号暂时风控)) {
                        logd("日志包含此账号暂时风控");
                        sleep(1000);
                        换号();
                    }

                    var 休息30分钟 = "休息30分钟";
                    if (插件日志的文本.includes(休息30分钟)) {
                        logd("日志包含休息30分钟");
                        sleep(1000);
                        换号();
                    }
                }
            }
            if (查找节点点击("账号密码登录", text("账号密码登录"), 1, 500)) {
                logd("账号密码登录")
                sleep(1100)
                if (查找节点点击("同意协议", checked(false).clz("android.widget.CheckBox"), 1, 5500)) {
                    logd("同意协议");
                    sleep(2100);
                    home()
                    sleep(1000)
                    home()
                    sleep(1000)
                    var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/"), 1000);
                    if (桌面编号 && 桌面编号 !== null) {
                        var 桌面编号元素 = 桌面编号.text;
                        logd(桌面编号元素);
                        sleep(1100)
                    }

                    utils.openAppByName("狐猴浏览器");
                    logd("启动狐猴浏览器");
                    sleep(1000);
                    let 读取账号文件 = file.readLine("/sdcard/Download/100账号.txt", 桌面编号元素);
                    if (读取账号文件) {
                        let 账号和密码 = 读取账号文件.split("----");
                        if (账号和密码.length > 0) {
                            var 该输入的账号 = 账号和密码[0].trim(); // 使用 trim 去除前后空格

                        }
                    }
                    let 输入账号 = getOneNodeInfo(id("username"), 11000);
                    if (输入账号) {
                        logd("输入账号")
                        sleep(1100)
                        输入账号.inputText(该输入的账号);
                        sleep(1000);
                        let 读取账号文件 = file.readLine("/sdcard/Download/100账号.txt", 桌面编号元素);
                        if (读取账号文件) {
                            let 账号和密码 = 读取账号文件.split("----");
                            if (账号和密码.length > 1) {
                                var 该输入的密码 = 账号和密码[1].trim(); // 使用 trim 去除前后空格

                            }
                        }
                        let 输入密码 = getOneNodeInfo(id("pwd"), 11000);
                        if (输入密码) {
                            logd("输入密码")
                            sleep(100)
                            输入密码.inputText(该输入的密码);
                            sleep(3100)
                            if (查找节点点击("登录", desc("登 录"), 2, 5200)) {
                                logd("登录")
                                sleep(1010)
                            }
                        }
                    }
                }
            }
            if (查找节点点击("安全验证", text("安全验证"), 1000, 500)) {
                logd("安全验证")
                sleep(100)
                home()
                sleep(1000)
                home()
                sleep(1000)
                var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/"), 1000);
                if (桌面编号 && 桌面编号 !== null) {
                    var 桌面编号元素 = 桌面编号.text;
                    logd(桌面编号元素);
                    sleep(1100)
                }
                if (查找节点点击("点击笔记", id("com.socialnmobile.dictapps.notepad.color.note:id/bg_image2"), 1, 500)) {
                    logd("点击笔记")
                    sleep(1100)
                    if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                        logd("编辑")
                        sleep(2100)
                        let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                        if (输入便签) {
                            agentEvent.setCurrentIme();
                            sleep(1010);
                            输入便签.imeInputText("==" + 桌面编号元素 + "安全验证");
                            sleep(1000);
                            agentEvent.restoreIme();
                        }
                    }
                }
                换号()
            }

            if (查找节点点击("开始任务", text("开始任务").id("task-start"), 1, 500)) {
                logd("开始任务")
                sleep(5100)
            }
            if (查找节点点击("账号或密码不正确", text("账号或密码不正确"), 1000, 500)) {
                logd("账号或密码不正确")
                sleep(100)
                home()
                sleep(1000)
                home()
                sleep(1000)
                var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/"), 1000);
                if (桌面编号 && 桌面编号 !== null) {
                    var 桌面编号元素 = 桌面编号.text;
                    logd(桌面编号元素);
                    sleep(1100)
                }
                if (查找节点点击("点击笔记", id("com.socialnmobile.dictapps.notepad.color.note:id/bg_image2"), 1, 500)) {
                    logd("点击笔记")
                    sleep(1100)
                    if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                        logd("编辑")
                        sleep(2100)
                        let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                        if (输入便签) {
                            agentEvent.setCurrentIme();
                            sleep(1010);
                            输入便签.imeInputText("==" + 桌面编号元素 + "账号或密码不正确");
                            sleep(1000);
                            agentEvent.restoreIme();
                        }
                    }
                }
                换号()
            }
            if (查找节点点击("账号存在风险", text("您的账号存在风险，为了您的账号安全请到京东商城App登录"), 1000, 500)) {
                logd("账号存在风险")
                sleep(100)
                home()
                sleep(1000)
                home()
                sleep(1000)
                var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/"), 1000);
                if (桌面编号 && 桌面编号 !== null) {
                    var 桌面编号元素 = 桌面编号.text;
                    logd(桌面编号元素);
                    sleep(1100)
                }
                if (查找节点点击("点击笔记", id("com.socialnmobile.dictapps.notepad.color.note:id/bg_image2"), 1, 500)) {
                    logd("点击笔记")
                    sleep(1100)
                    if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                        logd("编辑")
                        sleep(2100)
                        let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                        if (输入便签) {
                            agentEvent.setCurrentIme();
                            sleep(1010);
                            输入便签.imeInputText("==" + 桌面编号元素 + "账号存在风险");
                            sleep(1000);
                            agentEvent.restoreIme();
                        }
                    }
                }
                换号()
            }
            if (查找节点点击("封锁", text("您的账号因安全原因被暂时封锁，请将账号和联系方式发送到shensu@jd.com，我们将尽快为您处理"), 1000, 500)) {
                logd("账号被封锁")
                sleep(100)
                home()
                sleep(1000)
                home()
                sleep(1000)
                var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/"), 1000);
                if (桌面编号) {
                    var 桌面编号元素 = 桌面编号.text;
                    logd(桌面编号元素);
                    sleep(1100)
                }
                if (查找节点点击("点击笔记", id("com.socialnmobile.dictapps.notepad.color.note:id/bg_image2"), 1, 500)) {
                    logd("点击笔记")
                    sleep(1100)
                    if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                        logd("编辑")
                        sleep(2100)
                        let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                        if (输入便签) {
                            agentEvent.setCurrentIme();
                            sleep(1010);
                            输入便签.imeInputText("==" + 桌面编号元素 + "账号被封锁");
                            sleep(1000);
                            agentEvent.restoreIme();
                        }
                    }
                }
                换号()
            }
            var 领取数量 = getOneNodeInfo(id("task-total"), 500);
            if (领取数量 && 领取数量 !== null) {
                let 领取数量元素 = 领取数量.text;
                if (领取数量元素 === "9") {
                    logd("到9换号");
                    sleep(10000);
                    if (查找节点点击("停止任务", text("停止任务").id("task-start"), 1, 2500)) {
                        logd("停止任务")
                        sleep(100)
                    }
                    换号();
                }
            }
            // 添加非空判断以避免 'Cannot read property "text" from null' 错误

        }

    }

    function 换号() {

        换号次数++
        sleep(100)
        if (换号次数 == 93) {
            home()
            sleep(1000)
            home()
            sleep(1000)
            if (查找节点点击("点击笔记", id("com.socialnmobile.dictapps.notepad.color.note:id/bg_image2"), 1, 500)) {
                logd("点击笔记")
                sleep(1100)
                if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                    logd("编辑")
                    sleep(2100)
                    let 月 = new Date().getMonth() + 1;
                    let 日 = new Date().getDate();
                    let 日期 = (月) + "月" + (日) + "日";
                    let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                    if (输入便签) {
                        agentEvent.setCurrentIme();
                        sleep(1010);
                        输入便签.imeInputText("==" + 日期);
                        sleep(1000);
                        agentEvent.restoreIme();
                    }
                }
            }
            关屏等待()
        }
        /*      let 采集数量节点 = getOneNodeInfo(id('task-success'), 1000);
              if (采集数量节点 && 采集数量节点 !== null) {
                  var 采集数量 = 采集数量节点.text;
                  logd(采集数量);
                  sleep(1000);
                  home()
                  sleep(1000)
                  home()
                  sleep(1000)
                  var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/"), 1000);
                  if (桌面编号 && 桌面编号 !== null) {
                      var 桌面编号元素 = 桌面编号.text;
                      logd(桌面编号元素);
                      sleep(1100)
                  }
                  if (查找节点点击("点击笔记", id("com.socialnmobile.dictapps.notepad.color.note:id/bg_image2"), 1, 500)) {
                      logd("点击笔记")
                      sleep(1100)
                      if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                          logd("编辑")
                          sleep(2100)
                          let 月 = new Date().getMonth() + 1;
                          let 日 = new Date().getDate();
                          let 日期 = (月) + "月" + (日) + "日";
                          let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                          if (输入便签) {
                              agentEvent.setCurrentIme();
                              sleep(1010);
                              输入便签.imeInputText("==" + 桌面编号元素 + "-" + 采集数量);
                              sleep(1000);
                              agentEvent.restoreIme();
                          }
                      }
                  }

              } else {
                  home()
                  sleep(1000)
                  home()
                  sleep(1000)
                  var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/"), 1000);
                  if (桌面编号 && 桌面编号 !== null) {
                      var 桌面编号元素 = 桌面编号.text;
                      logd(桌面编号元素);
                      sleep(1100)
                  }
                  if (查找节点点击("点击笔记", id("com.socialnmobile.dictapps.notepad.color.note:id/bg_image2"), 1, 500)) {
                      logd("点击笔记")
                      sleep(1100)
                      if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                          logd("编辑")
                          sleep(2100)
                          let 月 = new Date().getMonth() + 1;
                          let 日 = new Date().getDate();
                          let 日期 = (月) + "月" + (日) + "日";
                          let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                          if (输入便签) {
                              agentEvent.setCurrentIme();
                              sleep(1010);
                              输入便签.imeInputText("==" + 桌面编号元素 + "-" + "*");
                              sleep(1000);
                              agentEvent.restoreIme();
                          }
                      }
                  }
              }*/
        home()
        sleep(1000)
        home()
        sleep(1000)
        let 桌面钛备份数据 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/"), 1000);
        if (桌面钛备份数据 && 桌面钛备份数据 !== null) {
            let 下一个数据 = ++桌面钛备份数据.text
            let 下一个数据编号 = 下一个数据.toString().padStart(4, '0'); // 使用padStart方法补零
            console.log(下一个数据编号); // 输出: "0005"
            sleep(1000);
            if (下一个数据编号 == '0101') {
                桌面钛备份数据.click();
                sleep(1000);
                let 该谁 = getOneNodeInfo(text("0001"), 1000)
                if (该谁) {
                    logd(下一个数据编号)
                    该谁.click();
                    sleep(1000);
                }

            } else {
                桌面钛备份数据.click();
                sleep(1000);
                for (; ;) {
                    let 该谁 = getOneNodeInfo(text(下一个数据编号), 1000)
                    if (该谁) {
                        logd(下一个数据编号)
                        该谁.click();
                        sleep(1000);
                        break;
                    } else {
                        swipeToPoint(503, 1511, 515, 737, 800);
                        sleep(1000);
                    }
                }
            }

        }

    }

    function 关屏等待() {

        home()
        sleep(1000)
        home()
        sleep(1000)
        logd("关屏等待")
        sleep(200);
        let 关屏状态 = getOneNodeInfo(id("com.android.systemui:id/keyguard_indication_text"), 1010)
        if (关屏状态) {
            sleep(2000);
        } else {
            shell.execCommand("input keyevent 26");
            toast("电源键")
            sleep(5000)
        }

        for (; ;) {
            let 关屏状态 = getOneNodeInfo(id("com.android.systemui:id/keyguard_indication_text"), 1000)
            if (关屏状态) {
                sleep(2000);
            } else {
                logd("开屏状态");
                sleep(1000);
                home()
                sleep(1000)
                home()
                sleep(1000)
                ui.showLogWindow();//显示日志
                let 月 = new Date().getMonth() + 1;
                let 日 = new Date().getDate();
                let 昨日 = new Date().getDate() - 1
                let 日期 = (月) + "月" + (日) + "日";
                let 昨天的日期 = (月) + "月" + (昨日) + "日";
                let str = getOneNodeInfo(id("android:id/text1"), 1000);
                if (str && str !== null) {
                    let char = 日期;
                    let 昨天的日期 = 昨天的日期;
                    if (str.text.includes(昨天的日期)) {
                        logw("==便签包含昨日==");
                        sleep(5000);
                        setTimeout(function () {
                            ui.closeLogWindow();
                        }, 15000); //5秒后关闭日志
                        if (查找节点点击("点击笔记", id("com.socialnmobile.dictapps.notepad.color.note:id/bg_image2"), 1, 500)) {
                            logd("点击笔记")
                            sleep(1100)
                            if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 11500)) {
                                logd("编辑")
                                sleep(1010)
                                if (查找节点点击并输入("输入", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), "--", 10)) {
                                    logd("输入")
                                    sleep(1000)
                                }

                            }
                        }
                    } else if (str.text.includes(char)) {
                        logw("==便签包含今日==");
                        sleep(60000 * 3);
                        setTimeout(function () {
                            ui.closeLogWindow();
                        }, 5000); //5秒后关闭日志
                        关屏等待()
                    } else {
                        logw("便签不包含今日");
                        sleep(1000);
                        logw("====开屏做任务====");
                        sleep(1000);
                        setTimeout(function () {
                            ui.closeLogWindow();
                        }, 5000); //5秒后关闭日志
                        home()
                        sleep(1000);
                        home()
                        sleep(1000);
                        狐猴()
                    }
                }

            }
        }
    }

    function X浏览器() {
        home()
        sleep(1000)
        home()
        sleep(1000)
        var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/").clz("android.widget.TextView"), 1000);
        if (桌面编号 && 桌面编号 !== null) {
            var 桌面编号元素 = 桌面编号.text;
            logd(桌面编号元素);
            sleep(1100)
        }
        let 月 = new Date().getMonth() + 1;
        let 日 = new Date().getDate();
        let 日期 = (月) + "月" + (日) + "日";
        let str = getOneNodeInfo(id("android:id/text1").index(0), 1000);
        if (str) {
            let 当前文本 = str.text;
            let 行数组 = 当前文本.split('\n');
            let 今日行数 = 0;
            // 统计包含今日日期的行数
            for (let i = 0; i < 行数组.length; i++) {
                let 指定行内容 = 行数组[i];
                if (指定行内容.includes(日期)) {
                    今日行数++;
                }
            }
            logd("包含今日的数量:" + 今日行数 + "次");
            if (今日行数 < 1) {
                logd("今日没有");
                if (查找节点点击("点击笔记", id("android:id/text1").index(0), 1, 1500)) {
                    logd("点击笔记")
                    sleep(1100)
                    if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                        logd("编辑")
                        sleep(2100)
                        let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                        if (输入便签) {
                            agentEvent.setCurrentIme();
                            输入便签.inputText("--");
                            sleep(1000);
                            agentEvent.restoreIme();
                            home()
                            sleep(1000)
                            home()
                            sleep(1000)
                        }

                    }
                }

            }
            if (今日行数 == 6) {
                logd("今日已满");
                X浏览器休息()
            }
            // 指定要检查的行号，例如第1行（索引为0）
            let 指定行号 = Number(桌面编号元素) - 1; // 索引从0开始，所以第2行的索引是1
            if (指定行号 >= 0 && 指定行号 < 行数组.length) {
                let 指定行内容 = 行数组[指定行号];
                if (指定行内容.includes(日期)) {
                    logd("指定行包含今日");
                    sleep(3000);
                    X浏览器换号()
                } else {
                    logd("指定行不包含今日");
                    sleep(2000);
                }
            }
        }
        for (; ;) {
            let X浏览器界面 = getOneNodeInfo(pkg("com.mmbox.xbrowser"), 500);
            if (X浏览器界面) {
                sleep(100);
                if (查找节点点击("脚本存在", id("gpd-main"), 1000, 100)) {
                    sleep(100);
                    没有加载脚本 = 0;
                } else {
                    logd("脚本没有加载" + 没有加载脚本)
                    sleep(100);
                    没有加载脚本++;
                    if (没有加载脚本 > 6) {
                        if (查找节点点击("脚本没有加载", id("com.mmbox.xbrowser:id/toolbar_btn_home").desc("主页"), 1, 500)) {
                            logd("脚本没有加载");
                            sleep(100);
                        }
                    }
                }
            } else {
                logd("没有存在");
                sleep(100);
                home();
                sleep(1000);
                home();
                sleep(1000);
                utils.openAppByName("X浏览器");
                sleep(3000);
                if (查找节点点击("回到首页", desc("主页").id("com.mmbox.xbrowser:id/toolbar_btn_home"), 1, 10500)) {
                    logd("回到首页")
                    sleep(100)
                }
                if (查找节点点击("打开京东", text("京东触屏版").index(1).depth(14), 1, 10500)) {
                    logd("打开京东");
                    sleep(2010);
                    if (查找节点点击("停止任务", id("gpd-stop-task"), 1, 10500)) {
                        logd("停止任务");
                        sleep(1100);
                        if (查找节点点击("确定", text("确定"), 3, 11050)) {
                            logd("确定");
                            sleep(5100);
                        }
                    } else {
                        if (查找节点点击("开启任务", text("开启任务"), 1, 3500)) {
                            logd("开启任务");
                            sleep(1100);
                            if (查找节点点击("确定", text("确定"), 3, 11050)) {
                                logd("确定");
                                sleep(1100);
                                if (查找节点点击("任务已启动", textMatch("任务已启动,请保持屏幕常亮"), 1000, 11500)) {
                                    logd("任务已启动")
                                    sleep(100)
                                    if (查找节点点击("获取任务中", textMatch("获取任务中."), 1000, 11500)) {
                                        logd("正常启动")
                                        sleep(1100)
                                    } else {
                                        if (查找节点点击("停止任务", id("gpd-stop-task"), 1, 10500)) {
                                            logd("停止任务");
                                            sleep(1100);
                                            if (查找节点点击("确定", text("确定"), 3, 11050)) {
                                                logd("确定");
                                                sleep(5100);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            let 关屏状态 = getOneNodeInfo(id("com.android.systemui:id/keyguard_indication_text"), 100)
            if (关屏状态) {
                sleep(2000);
                X浏览器休息()
            }
            if (查找节点点击("脚本缩回状态", id("gdp-open-icon"), 2, 500)) {
                logd("脚本缩回状态");
                sleep(1010);
            }
            if (查找节点点击("活动火爆", text("活动太火爆啦"), 1000, 500)) {
                logd("活动火爆");
                sleep(100);
                X浏览器换号()
            }

            if (查找节点点击("暂无任务", textMatch("暂无任务 任务已停止!"), 1000, 500)) {
                logd("暂无任务")
                sleep(100)
                shell.execCommand("input keyevent 26");
                toast("电源键")
                sleep(5000)
                for (; ;) {
                    let 关屏状态 = getOneNodeInfo(id("com.android.systemui:id/keyguard_indication_text"), 1010)
                    if (关屏状态) {
                        sleep(2000);
                    } else {
                        logd("开屏继续")
                        sleep(2000)
                        break
                    }
                }
            }
            if (查找节点点击("活动火爆提示", textMatch("活动火爆，请休息1天或更"), 1000, 500)) {
                logd("活动火爆");
                sleep(100);
                X浏览器换号()
            }
            if (查找节点点击("账号任务暂停", textMatch("当前账号任务已暂停"), 1000, 500)) {
                logd("账号任务暂停");
                home();
                sleep(1000);
                home();
                sleep(1000);
                var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/").clz("android.widget.TextView"), 1000);
                if (桌面编号 && 桌面编号 !== null) {
                    var 桌面编号元素 = 桌面编号.text;
                    logd(桌面编号元素);
                    sleep(1100)
                }
                if (查找节点点击("点击笔记", id("android:id/text1").index(1), 1, 1500)) {
                    logd("点击笔记")
                    sleep(1100)
                    if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                        logd("编辑")
                        sleep(2100)
                        let 月 = new Date().getMonth() + 1;
                        let 日 = new Date().getDate();
                        let 日期 = (月) + "月" + (日) + "日";
                        let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                        if (输入便签) {
                            agentEvent.setCurrentIme();
                            sleep(1010);
                            let 当前文本 = 输入便签.text; // 直接访问 text 属性
                            let 行数组 = 当前文本.split('\n');
                            // 指定要插入的行号，例如在第2行插入（索引为1）
                            let 指定行号 = Number(桌面编号元素) - 1; // 索引从0开始，所以第2行的索引是1
                            let 新内容 = "(" + 桌面编号元素 + "-" + "账号暂停" + 日期 + ")";
                            行数组[指定行号] = 新内容;
                            let 修改后文本 = 行数组.join('\n');
                            输入便签.imeInputText("");
                            输入便签.inputText(修改后文本);
                            logd("输入修改后的内容");
                            sleep(1000);
                            agentEvent.restoreIme();
                            X浏览器换号()
                        }
                    }
                }
            }
            if (查找节点点击("出现验证", text("验证一下，购物无忧"), 1000, 500)) {
                logd("出现验证");
                sleep(100);
                X浏览器换号();
            }

            if (查找节点点击("开启任务", text("开启任务"), 11, 500)) {
                logd("开启任务");
                sleep(1100);

                if (查找节点点击("还是限额", textMatch("当前账号提交已限额"), 1000, 2500)) {
                    logw("---限额---");
                    sleep(2100);
                    X浏览器换号();
                }
                if (查找节点点击("任务未开启", textMatch("任务未开启，请"), 1000, 1500)) {
                    logd("任务未开启");
                    sleep(100);
                    X浏览器休息()
                }
                if (查找节点点击("活动火爆提示", textMatch("活动火爆，请休息1天或更"), 1000, 1500)) {
                    logd("活动火爆");
                    sleep(100);
                    X浏览器换号();
                }
                if (查找节点点击("已轮休", textMatch("当前账号任务已轮休，请更换账号或明日再试"), 1000, 1500)) {
                    logw("==已轮休==");
                    sleep(2100);
                    home();
                    sleep(1000);
                    home();
                    sleep(1000);
                    var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/").clz("android.widget.TextView"), 1000);
                    if (桌面编号 && 桌面编号 !== null) {
                        var 桌面编号元素 = 桌面编号.text;
                        logd(桌面编号元素);
                        sleep(1100)
                    }
                    if (查找节点点击("点击笔记", id("android:id/text1").index(1), 1, 1500)) {
                        logd("点击笔记")
                        sleep(1100)
                        if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                            logd("编辑")
                            sleep(2100)
                            let 月 = new Date().getMonth() + 1;
                            let 日 = new Date().getDate();
                            let 日期 = (月) + "月" + (日) + "日";
                            let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                            if (输入便签) {
                                agentEvent.setCurrentIme();
                                sleep(1010);
                                let 当前文本 = 输入便签.text; // 直接访问 text 属性
                                let 行数组 = 当前文本.split('\n');
                                // 指定要插入的行号，例如在第2行插入（索引为1）
                                let 指定行号 = Number(桌面编号元素) - 1; // 索引从0开始，所以第2行的索引是1
                                let 新内容 = "(" + 桌面编号元素 + "-" + "已轮休" + 日期 + ")";
                                行数组[指定行号] = 新内容;
                                let 修改后文本 = 行数组.join('\n');
                                输入便签.imeInputText("");
                                输入便签.inputText(修改后文本);
                                logd("输入修改后的内容");
                                sleep(1000);
                                agentEvent.restoreIme();
                                X浏览器换号()
                            }
                        }
                    }
                }
                if (查找节点点击("活动火爆提示", textMatch("活动火爆，请休息1天或更"), 1000, 1500)) {
                    logd("活动火爆");
                    sleep(100);
                    X浏览器换号();
                }
                if (查找节点点击("开启任务", text("开启任务"), 1, 500)) {
                    logd("开启任务");
                    sleep(1100);
                    if (查找节点点击("确定", text("确定"), 3, 11050)) {
                        logd("确定");
                        sleep(1100);
                        if (查找节点点击("任务已启动", textMatch("任务已启动,请保持屏幕常亮"), 1000, 11500)) {
                            logd("任务已启动")
                            sleep(100)
                            if (查找节点点击("获取任务中", textMatch("获取任务中."), 1000, 11500)) {
                                logd("正常启动")
                                sleep(1100)
                            } else {
                                if (查找节点点击("停止任务", id("gpd-stop-task"), 1, 10500)) {
                                    logd("停止任务");
                                    sleep(1100);
                                    if (查找节点点击("确定", text("确定"), 3, 11050)) {
                                        logd("确定");
                                        sleep(5100);
                                    }
                                }
                            }
                        }

                    }
                }
            }

            if (查找节点点击("同意协议", checked(false).clz("android.widget.CheckBox"), 1, 500)) {
                logd("同意协议");
                sleep(2100);
            }
            if (查找节点点击("请输入密码", text("请输入密码"), 11, 500)) {
                logd("请输入密码");
                sleep(1100);
                home();
                sleep(1000);
                home();
                sleep(1000);
                var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/").clz("android.widget.TextView"), 1000);
                if (桌面编号 && 桌面编号 !== null) {
                    var 桌面编号元素 = 桌面编号.text;
                    logd(桌面编号元素);
                    var 账号密码映射 = {
                        1: {输入账号: 账号, 输入密码: 密码},
                        2: {输入账号: 账号2, 输入密码: 密码2},
                        3: {输入账号: 账号3, 输入密码: 密码3},
                        4: {输入账号: 账号4, 输入密码: 密码4},
                        5: {输入账号: 账号5, 输入密码: 密码5},
                        6: {输入账号: 账号6, 输入密码: 密码6}
                    };
                    var 选择的账号密码 = 账号密码映射[桌面编号元素];

                    if (选择的账号密码) {
                        var {输入账号, 输入密码} = 选择的账号密码;
                        // 使用 输入账号 和 输入密码 进行后续操作
                    }
                }
                sleep(1000)
                utils.openAppByName("X浏览器");
                logd("启动X浏览器");
                sleep(3000);
                if (查找节点点击并输入("输入密码", id("pwd"), 输入密码, 10510)) {
                    logd("输入密码");
                    sleep(1000);
                    if (查找节点点击并输入("输入账号", id("username"), 输入账号, 5110)) {
                        logd("输入账号");
                        sleep(1000);
                    }
                }
            }


            if (查找节点点击("网页无法打开", text("网页无法打开"), 1000, 500)) {
                logd("网页无法打开");
                sleep(100);
                if (查找节点点击("主页", id("com.lemurbrowser.exts:id/home_button"), 1, 1500)) {
                    logd("主页");
                    sleep(4100);
                }
            }

            if (查找节点点击("服务器出错", textMatch("methodName"), 1000, 500)) {
                logw("---服务器出错---");
                sleep(1500);
                if (查找节点点击("确定", text("确定"), 3, 11050)) {
                    logd("确定");
                    sleep(3100);
                    if (查找节点点击("主页", id("com.mmbox.xbrowser:id/toolbar_btn_home"), 1, 1500)) {
                        logd("主页")
                        sleep(1100)
                    }
                }
            }
            if (查找节点点击("账号密码登录", text("账号密码登录"), 1, 500)) {
                logd("账号密码登录");
                sleep(1010);
            }

            if (查找节点点击("已经输入", textMatch("•").id("pwd"), 1000, 500)) {
                logd("已经输入");
                sleep(100);
                if (查找节点点击("登录", text("登 录"), 1, 500)) {
                    logd("登录");
                    sleep(3100);
                }
                if (查找节点点击("同意协议", checked(false).clz("android.widget.CheckBox"), 1, 500)) {
                    logd("同意协议");
                    sleep(2100);
                }
            }
            if (查找节点点击("请检查您的账号状态", text("请检查您的账号状态，重新登陆后再进行尝试"), 1000, 500)) {
                logd("请检查您的账号状态");
                sleep(1100);
                if (查找节点点击("确定", text("确定"), 1, 500)) {
                    logd("确定");
                    sleep(3111);
                    if (查找节点点击("掉号", id("msShortcutLogin"), 3, 500)) {
                        logd("掉号了哦");
                        sleep(3100);
                    }
                }
            }
            if (查找节点点击("账号风险", text("您的账号存在风险，为了您的账号安全请到京东商城App登录"), 1000, 500)) {
                logw("----账号风险----");
                sleep(100);
                home();
                sleep(1000);
                home();
                sleep(1000);
                var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/").clz("android.widget.TextView"), 1000);
                if (桌面编号 && 桌面编号 !== null) {
                    var 桌面编号元素 = 桌面编号.text;
                    logd(桌面编号元素);
                    sleep(1100)
                }
                if (查找节点点击("点击笔记", id("android:id/text1").index(1), 1, 1500)) {
                    logd("点击笔记")
                    sleep(1100)
                    if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                        logd("编辑")
                        sleep(2100)
                        let 月 = new Date().getMonth() + 1;
                        let 日 = new Date().getDate();
                        let 日期 = (月) + "月" + (日) + "日";
                        let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                        if (输入便签) {
                            agentEvent.setCurrentIme();
                            sleep(1010);
                            let 当前文本 = 输入便签.text; // 直接访问 text 属性
                            let 行数组 = 当前文本.split('\n');
                            // 指定要插入的行号，例如在第2行插入（索引为1）
                            let 指定行号 = Number(桌面编号元素) - 1; // 索引从0开始，所以第2行的索引是1
                            let 新内容 = "(" + 桌面编号元素 + "-" + "账号风险" + 日期 + ")";
                            行数组[指定行号] = 新内容;
                            let 修改后文本 = 行数组.join('\n');
                            输入便签.imeInputText("");
                            输入便签.inputText(修改后文本);
                            logd("输入修改后的内容");
                            sleep(1000);
                            agentEvent.restoreIme();
                            X浏览器换号()
                        }
                    }
                }

            }
            if (查找节点点击("登录安全验证", text("安全验证"), 1000, 500)) {
                logd("登录安全验证");
                sleep(100);
                home();
                sleep(1000);
                home();
                sleep(1000);
                var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/").clz("android.widget.TextView"), 1000);
                if (桌面编号 && 桌面编号 !== null) {
                    var 桌面编号元素 = 桌面编号.text;
                    logd(桌面编号元素);
                    sleep(1100)
                }
                if (查找节点点击("点击笔记", id("android:id/text1").index(1), 1, 1500)) {
                    logd("点击笔记")
                    sleep(1100)
                    if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                        logd("编辑")
                        sleep(2100)
                        let 月 = new Date().getMonth() + 1;
                        let 日 = new Date().getDate();
                        let 日期 = (月) + "月" + (日) + "日";
                        let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                        if (输入便签) {
                            agentEvent.setCurrentIme();
                            sleep(1010);
                            let 当前文本 = 输入便签.text; // 直接访问 text 属性
                            let 行数组 = 当前文本.split('\n');
                            // 指定要插入的行号，例如在第2行插入（索引为1）
                            let 指定行号 = Number(桌面编号元素) - 1; // 索引从0开始，所以第2行的索引是1
                            let 新内容 = "(" + 桌面编号元素 + "-" + "登录验证" + 日期 + ")";
                            行数组[指定行号] = 新内容;
                            let 修改后文本 = 行数组.join('\n');
                            输入便签.imeInputText("");
                            输入便签.inputText(修改后文本);
                            logd("输入修改后的内容");
                            sleep(1000);
                            agentEvent.restoreIme();
                            X浏览器换号()
                        }
                    }
                }
            }
            if (查找节点点击("打开京东", text("京东触屏版").index(1).depth(14), 1, 500)) {
                logd("打开京东");
                sleep(2010);
                if (查找节点点击("停止任务", id("gpd-stop-task"), 1, 10500)) {
                    logd("停止任务");
                    sleep(1100);
                    if (查找节点点击("确定", text("确定"), 3, 11050)) {
                        logd("确定");
                        sleep(5100);
                    }
                } else {
                    if (查找节点点击("开启任务", text("开启任务"), 1, 3500)) {
                        logd("开启任务");
                        sleep(1100);
                        if (查找节点点击("确定", text("确定"), 3, 11050)) {
                            logd("确定");
                            sleep(1100);
                            if (查找节点点击("任务已启动", textMatch("任务已启动,请保持屏幕常亮"), 1000, 11500)) {
                                logd("任务已启动")
                                sleep(100)
                                if (查找节点点击("获取任务中", textMatch("获取任务中."), 1000, 11500)) {
                                    logd("正常启动")
                                    sleep(1100)
                                } else {
                                    if (查找节点点击("停止任务", id("gpd-stop-task"), 1, 10500)) {
                                        logd("停止任务");
                                        sleep(1100);
                                        if (查找节点点击("确定", text("确定"), 3, 11050)) {
                                            logd("确定");
                                            sleep(5100);
                                        }
                                    }
                                }
                            }

                        }
                    }
                }
            }
            if (查找节点点击("版本太低", textMatch("版本过低，请升级"), 1000, 500)) {
                logd("---暂无任务---");
                sleep(3000);
                if (查找节点点击("主菜单", id("com.mmbox.xbrowser:id/toolbar_btn_menu").desc("主菜单"), 3, 3500)) {
                    logd("主菜单");
                    sleep(2100);
                    if (查找节点点击("打开设置", id("com.mmbox.xbrowser:id/menu_bottom_setting").desc("打开设置"), 3, 3500)) {
                        logd("打开设置");
                        sleep(1100);
                        if (查找节点点击("用户脚本", text("用户脚本"), 3, 3500)) {
                            logd("用户脚本");
                            sleep(1100);
                            if (查找节点点击("点三个点", text(""), 3, 3500)) {
                                logd("点三个点");
                                sleep(1100);
                                if (查找节点点击("更新", text("更新").id("com.mmbox.xbrowser:id/menu_item_title"), 1, 3500)) {
                                    logd("点三个点");
                                    sleep(21100);
                                    home();
                                    sleep(1000);
                                    home();
                                    sleep(1000);
                                }
                            }
                        }
                    }
                }
            }
            if (查找节点点击("请求失败", textMatch("请求失败: 请更换网络后再获取任务!"), 1000, 500)) {
                logw("---请更换网络---");
                sleep(1700);
                var IP网址 = "http://checkip.amazonaws.com/";
                var pa = {"b": "22"};
                var 第一个IP = http.httpGet(IP网址, pa, 1000, {"User-Agent": "test"});
                logd("第一个IP" + 第一个IP)
                sleep(1000)
                if (第一个IP == null) {
                    logw("没有IP继续等待")
                    sleep(30000)
                } else if (第一个IP.length > 35) {
                    logw("没有IP继续等待")
                    sleep(30000)
                } else {
                    for (; ;) {
                        let IP网址2 = "http://checkip.amazonaws.com/";
                        let pa2 = {"b": "22"};
                        let 第二个IP = http.httpGet(IP网址2, pa2, 1000, {"User-Agent": "test"});
                        logd("第二个IP" + 第二个IP)
                        sleep(1100)
                        if (第二个IP == null) {
                            logw("没有IP继续等待null")
                            sleep(11000)
                        } else if (第二个IP.length > 35) {
                            logw("没有IP继续等待length")
                            sleep(11000)
                        } else if (第二个IP == 第一个IP) {
                            logw("没有切换继续等待==")
                            sleep(11000)
                        } else {
                            logw("------切换成功-----")
                            sleep(1000)
                            break;
                        }
                    }
                }


            }

        }
    }

    function X浏览器换号() {
        let 最后条数 = 今日条数 ? 今日条数.text : (最后有效今日条数 ? 最后有效今日条数.text : "X")
        if (最后条数) {
            home()
            sleep(1000)
            home()
            sleep(1000)
            var 桌面编号 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/").clz("android.widget.TextView"), 1000);
            if (桌面编号 && 桌面编号 !== null) {
                var 桌面编号元素 = 桌面编号.text;
                logd(桌面编号元素);
                sleep(1100)
            }
            if (查找节点点击("点击笔记", id("android:id/text1").index(0), 1, 1500)) {
                logd("点击笔记")
                sleep(1100)
                if (查找节点点击("编辑", id("com.socialnmobile.dictapps.notepad.color.note:id/edit_btn"), 1, 1500)) {
                    logd("编辑")
                    sleep(2100)
                    let 月 = new Date().getMonth() + 1;
                    let 日 = new Date().getDate();
                    let 日期 = (月) + "月" + (日) + "日";
                    let 输入便签 = getOneNodeInfo(id("com.socialnmobile.dictapps.notepad.color.note:id/edit_note"), 1000);
                    if (输入便签) {
                        agentEvent.setCurrentIme();
                        sleep(1010);
                        let 当前文本 = 输入便签.text; // 直接访问 text 属性
                        let 行数组 = 当前文本.split('\n');
                        // 指定要插入的行号，例如在第2行插入（索引为1）
                        let 指定行号 = Number(桌面编号元素) - 1; // 索引从0开始，所以第2行的索引是1
                        let 新内容 = "(" + 桌面编号元素 + "-" + 最后条数 + "-" + 日期 + " )";
                        行数组[指定行号] = 新内容;
                        let 修改后文本 = 行数组.join('\n');
                        输入便签.imeInputText("");
                        输入便签.inputText(修改后文本);
                        logd("输入修改后的内容");
                        sleep(1000);
                        agentEvent.restoreIme();
                    }


                }
            }

        }
        for (; ;) {
            var IP网址 = "http://checkip.amazonaws.com/";
            var pa = {"b": "22"};
            var 现在的网址 = http.httpGet(IP网址, pa, 3000, {"User-Agent": "test"});
            logd(现在的网址)
            sleep(1000);
            var IP文件2 = file.exists("/sdcard/IP2.txt/");
            if (IP文件2 == false) {
                sleep(100)
                file.appendLine(现在的网址, "/sdcard/IP2.txt");
                sleep(1000)
            } else {
                file.writeFile(现在的网址, "/sdcard/IP2.txt");
                sleep(1000)
            }
            var IP文件1 = file.readLine("/sdcard/IP.txt", 1);
            logd(IP文件1)
            sleep(1000)
            var IP文件2 = file.readLine("/sdcard/IP2.txt", 1);
            logd(IP文件2)
            sleep(1000)
            if (IP文件2 == IP文件1) {
                logd("等待换IP")
                sleep(10000)
            } else if (IP文件2 == null) {
                logw("没有IP继续等待")
                sleep(10000)
            } else if (IP文件2.length > 35) {
                logw("没有IP继续等待")
                sleep(10000)
            } else {
                logd("IP不相同")
                sleep(1000)
                file.writeFile(IP文件2, "/sdcard/IP.txt");
                sleep(1000)
                break
            }
        }
        home()
        sleep(1000)
        home()
        sleep(1000)
        let 桌面钛备份数据 = getOneNodeInfo(id("com.keramidas.TitaniumBackup:id/").clz("android.widget.TextView"), 1000);
        if (桌面钛备份数据 && 桌面钛备份数据 !== null) {
            var 下一个数据 = ++桌面钛备份数据.text
            logd(下一个数据)
            if (下一个数据 == '7') {
                桌面钛备份数据.click();
                sleep(1000);
                for (; ;) {
                    let 该谁 = getOneNodeInfo(text("1"), 1000)
                    if (该谁) {
                        logd("回到1")
                        该谁.click();
                        sleep(1000);
                        break;
                    } else {
                        swipeToPoint(503, 1511, 515, 737, 800);
                        sleep(1000);
                    }
                }
            } else {
                桌面钛备份数据.click();
                sleep(1000);
                for (; ;) {
                    let 该谁 = getOneNodeInfo(text(下一个数据), 1000)
                    if (该谁) {
                        logd(下一个数据)
                        该谁.click();
                        sleep(1000);
                        break;
                    } else {
                        swipeToPoint(503, 1511, 515, 737, 800);
                        sleep(1000);
                    }
                }
            }

        }
        X浏览器()
    }

    function X浏览器休息() {
        logw("===休息===")
        sleep(1000);
        logw("===休息===")
        sleep(1000);
        ui.showLogWindow();//显示日志
        setTimeout(function () {
            ui.closeLogWindow();
        }, 10000); //10秒后关闭日志
        sleep(30000)
        home()
        sleep(1000)
        home()
        sleep(1000)

        let 关屏状态 = getOneNodeInfo(id("com.android.systemui:id/keyguard_indication_text"), 1010)
        if (关屏状态) {
            sleep(2000);
        } else {
            shell.execCommand("input keyevent 26");
            toast("电源键")
            sleep(5000)
        }

        for (; ;) {
            let 关屏状态 = getOneNodeInfo(id("com.android.systemui:id/keyguard_indication_text"), 1000)
            if (关屏状态) {
                sleep(2000);
            } else {
                logd("开屏状态");
                sleep(1000);
                ui.showLogWindow();//显示日志
                setTimeout(function () {
                    ui.closeLogWindow();
                }, 10000); //10秒后关闭日志
                for (let i = 0; i < 10; i++) {
                    let 关屏状态 = getOneNodeInfo(id("com.android.systemui:id/keyguard_indication_text"), 1010)
                    if (关屏状态) {
                        logd("继续关屏")
                        sleep(200);
                        关屏等待()
                        sleep(1000);
                    }
                }
                logd("开屏做任务");
                sleep(1000);
                home()
                sleep(1000);
                home()
                sleep(1000);
                X浏览器()
            }
        }
    }

   
    function 死号() {
        sleep(150)
        for (; ;) {
            let 账号掉了的数据 = JSON.stringify({"num": 本机编号, "xystatus": "掉线", "remarks": ""})
            let 掉账号 = http.postJSON(服务器账号状态链接, 账号掉了的数据, 10 * 1000, {"User-Agent": "test"});
            if (掉账号 === "OK") {
                logd("成功")
                sleep(1000)
            } else {
                logd("失败")
                sleep(10000)
            }
            logd("掉了")
            sleep(1000)
            exit()
            sleep(1000)

        }

    }

    function 更新() {
        sleep(random(1000, 30000))
        let id2 = startJob("task2", "4", true);
        toast("job id " + id2);
        sleep(1000)
        exit()
    }


    function 热更新() {
        for (let i = 0; i < 30; i++) {
            let cm = context.getSystemService(context.CONNECTIVITY_SERVICE);
            let net = cm.getActiveNetworkInfo();
            if (net == null || !net.isAvailable()) {
                toast("网络未连接");
                sleep(1000)
                toast("网络未连接");
                sleep(1000)
                utils.openIntentAction("android.settings.WIFI_SETTINGS")
                toast("进入wifi选项")
                sleep(2000)
                for (let i = 0; i < 30; i++) {
                    if (查找节点点击("关", text("关"), 1, 3100)) {
                        logd("关")
                        sleep(10000)
                        break
                    }
                    if (查找节点点击("高级", text("高级"), 1, 3100)) {
                        logd("高级")
                        sleep(1100)
                    }
                    if (查找节点点击("管理网络", text("管理网络"), 1, 3100)) {
                        logd("管理网络")
                        sleep(20000)
                        back()
                        sleep(1000)
                        back()
                        sleep(1000)
                        back()
                        sleep(1000)
                        break
                    }

                }
            } else {
                toast("网络连接正常")
                sleep(2000)
                let url = "https://wdsanxingn8.oss-cn-beijing.aliyuncs.com/updete.txt"
                var 分解对象 = http.httpGetDefault(url, 10 * 1000, {"User-Agent": "test"});
                toast("当前版本 -> " + version);
                sleep(1000)
                toast("服务器版本 -> " + 分解对象);
                sleep(1000)
                var 分解对象为空 = utils.isObjectNull(分解对象);
                if (分解对象为空) {
                    sleep(2000)
                    logd("获取更新地址失败")
                    sleep(1000)
                    break
                } else {
                    if (version < 分解对象) {
                        logd("开始自动更新")
                        sleep(1000)
                        let 对象下载地址 = "https://wdsanxingn8.oss-cn-beijing.aliyuncs.com/release.iec"
                        if (对象下载地址 !== "") {
                            logd(对象下载地址)
                            let down = http.downloadFile(对象下载地址, "/sdcard/release.iec", 10 * 1000, {"User-Agent": "test"});
                            toast("下载:" + down);
                            sleep(2000);
                            zipFile = "/sdcard/release.iec"

                            sleep(2000);
                            let result = setIECPath("/sdcard/release.iec");
                            toast("result : " + result);
                            sleep(2000)
                            //开启定时任务准备下一次执行
                            let id2 = startJob("task2", "4", true);
                            toast("job id " + id2);
                            sleep(1000)
                            exit()
                        } else {
                            toast(对象地址);
                            sleep(2000)
                            break

                        }
                    } else {
                        toast("没有更新");
                        sleep(3000);
                        break

                    }

                }
                break;
            }
        }//热更新
        main()
    }

    function 查找节点点击(备注, 查找, 点击, 找寻时间) {
        let 节点 = 查找.getOneNodeInfo(找寻时间);
        if (节点) {
            if (点击 == 1) {
                节点.click()
                sleep(random(500, 1000));
            }
            if (点击 === 2) {
                节点.clickCenter();
                sleep(random(500, 1000));
            }
            if (点击 === 3) {
                节点.clickEx();
                sleep(random(500, 1000));
            }
            if (点击 === 4) {
                节点.longClick();
                sleep(random(500, 1000));
            }
            return true;
        }
        return false;
    }


    function 查找节点点击并输入(备注, 查找, 内容, 延迟时间) {
        let 节点 = 查找.getOneNodeInfo(延迟时间);
        if (节点) {
            节点.clickCenter()
            sleep(random(500, 1000));
            (节点).inputText(内容);
            sleep(random(500, 1000));
            return true;
        }
        return false;
    }


    function 找图点击(图片, 是否点击) {
        let bitmap = image.captureScreenBitmap("png", -1, 0, 0, 0, 100);
        let temp = readResBitmap(图片 + ".png");
        let rects = imageHandler.findImgFast(bitmap, temp, 0.9, -1, 0, 0, 0, 10, true);
        if (rects) {
            if (是否点击 == 1) {
                clickPoint(rects[0].left, rects[0].top)
                sleep(1000)
            }
            imageHandler.recycle(bitmap, temp)
            sleep(10)
            return true;
        }
        imageHandler.recycle(bitmap, temp)
        sleep(10)
        return false;
    }

    function moveFun(qx, qy, zx, zy, time) {
        var xxy = [];
        var points = [];

        //设置控制点极限距离
        var leaveHeightLength = 500

        var point1 = {
            "x": qx,
            "y": qy
        };

        //根据偏差距离，应用不同的随机方式
        if (Math.abs(zx - qx) > Math.abs(zy - qy)) {
            var my = (qy + zy) / 2
            var y2 = my + random(0, leaveHeightLength)
            var y3 = my - random(0, leaveHeightLength)

            var lx = (qx - zx) / 3
            if (lx < 0) {
                lx = -lx
            }
            var x2 = qx + lx / 2 + random(0, lx)
            var x3 = qx + lx + lx / 2 + random(0, lx)
        } else {
            var mx = (qx + zx) / 2
            var y2 = mx + random(0, leaveHeightLength)
            var y3 = mx - random(0, leaveHeightLength)

            var ly = (qy - zy) / 3
            if (ly < 0) {
                ly = -ly
            }
            var y2 = qy + ly / 2 + random(0, ly)
            var y3 = qy + ly + ly / 2 + random(0, ly)
        }

        var point2 = {
            "x": x2,
            "y": y2
        };
        var point3 = {
            "x": x3,
            "y": y3,
        };
        var point4 = {
            "x": zx,
            "y": zy
        };


        points.push(point1);
        points.push(point2);
        points.push(point3);
        points.push(point4);

        let targetP;
        for (let i = 0; i < 1; i += 0.08) {
            targetP = bezier_curves(points, i);
            xxy.push([parseInt(targetP.x), parseInt(targetP.y)]);
        }

        let touch1 = [];
        let _time = time / xxy.length;

        touch1.push({"action": 0, "x": xxy[0][0], "y": xxy[0][1], "pointer": 1, "delay": _time})
        for (let i = 2; i < xxy.length - 1; i++) {
            touch1.push({"action": 2, "x": xxy[i][0], "y": xxy[i][1], "pointer": 1, "delay": _time})
        }
        touch1.push({
            "action": 1,
            "x": xxy[xxy.length - 1][0],
            "y": xxy[xxy.length - 1][1],
            "pointer": 1,
            "delay": _time
        })

        let x = multiTouch(touch1, null, null, 30000);
    };

    function bezier_curves(cp, t) {
        let cx = 3.0 * (cp[1].x - cp[0].x);
        let bx = 3.0 * (cp[2].x - cp[1].x) - cx;
        let ax = cp[3].x - cp[0].x - cx - bx;
        let cy = 3.0 * (cp[1].y - cp[0].y);
        let by = 3.0 * (cp[2].y - cp[1].y) - cy;
        let ay = cp[3].y - cp[0].y - cy - by;

        let tSquared = t * t;
        let tCubed = tSquared * t;
        let result = {
            "x": 0,
            "y": 0
        };
        result.x = (ax * tCubed) + (bx * tSquared) + (cx * t) + cp[0].x;
        result.y = (ay * tCubed) + (by * tSquared) + (cy * t) + cp[0].y;
        return result;
    };

    function 打开应用信息界面(pkgName) {
        //打开应用信息界面的用法
        // 打开应用信息界面("com.huzan.automatic")
        // sleep(3000)
        // let 结束运行 = getOneNodeInfo(text("结束运行").pkg("com.miui.securitycenter"), 3000)
        // if (结束运行) {
        //     (结束运行).click()
        //     sleep(2000)
        //     let 确定 = getOneNodeInfo(text("确定"), 3000)
        //     if (确定) {
        //         (确定).click()
        //         sleep(2000)
        //         back()
        //         sleep(1000)
        //         back()
        //         sleep(1000)
        //     }
        //
        // }
        return utils.openActivity({
            "action": "android.settings.APPLICATION_DETAILS_SETTINGS",
            "uri": "package:" + pkgName
        });
    }

    function 停止应用(包名) {

        utils.openActivity({
            "action": "android.settings.APPLICATION_DETAILS_SETTINGS",
            "uri": "package:" + 包名
        });
        sleep(1000)
        if (查找节点点击("强制停止", text("强制停止"), 1, 1111)) {
            logd("强制停止")
            sleep(1000)
            if (查找节点点击("强制停止", text("强制停止"), 1, 1510)) {
                logd("强制停止")
                back()
                sleep(1000)
                back()
                sleep(1000)
                back()
                sleep(1000)
            }
        }
        if (查找节点点击("强行停止", text("强行停止"), 1, 1111)) {
            logd("强行停止")
            sleep(1010)
            if (查找节点点击("确定", text("确定"), 1, 1500)) {
                logd("确定")
                sleep(1010)
            }
            back()
            sleep(1000)
            back()
            sleep(1000)
            back()
            sleep(1000)
        }
    }

    function 检查图片(图片1) {
        let 本地图片 = 图片1
        let 图片是否存在 = file.exists("/sdcard/找图/" + 本地图片 + ".png");
        if (图片是否存在 == false) {
            let 图片下载地址 = "https://gitee.com/sun-jian-8341/tuse/raw/master/tuse/" + 本地图片 + ".png"
            if (图片下载地址 !== "") {
                let down = http.downloadFile(图片下载地址, "/sdcard/找图/" + 本地图片 + ".png", 10 * 1000, {"User-Agent": "test"});
                toast("下载:" + down);
                sleep(2000);
            }
            return true;
        }
        return false;
        sleep(100)
    }

